package cn.all;
/*
 * 1-26题
 */
import java.lang.reflect.Array;
import java.util.Scanner;

public class DoProg {

	public static void main(String[] args) {
		// 判断是闰年还是平年
		// isLeapYear(1900);
		// 计算兔子数量
		// countRabbit();
		// 找素数
		// findPrime();
		// 水仙花数
		// narcissistic();
		// decompose(90);
		// output(78);
		// maxDivisor(10, 95);
		// minMultiple(2, 5);
		// countNum();
		// 求和
		// iSum(2, 5);
		// 找完数
		// perfactNum(1000);
		// perfactNum(1, 1000);
		// falling(100, 10);
		// 找1,2,3,4能组成的不同的数
		// makeNum();
		// 方法2
		int[] arr1 = bigArray();
		// makeNum(arr1);
		// 方法3
		// makeNum1(arr1);
		// printArr(arr1);

		// 完全平方数
		// num100168();

		// 第几天
		// day(2018, 4, 1);
		// 对战名单
		// list();
		// 数列求和
		// sumSeq();
		// sumFactor(20);
		// seqAge(5);
		// printRhombus(25);
		//reverseNum(12345L);
		//reverseNum2(123456789L);
		//isPalindromic(1234321L);
		weekday();
	}
	
	/*
	 * 题目：请输入星期几的第一个字母来判断一下是星期几，
	 * 如果第一个字母一样，则继续   判断第二个字母。
	 */
	
	private static void weekday() {
		//scanner 实例化
		Scanner sc = new Scanner(System.in);
		//接收输入变量
		String str = "";
		char[] day= new char[5];
		//提示输入
		System.out.println("请输入需要判定的星期几的首字母");
		if(sc.hasNext()) {
			str=sc.next();
		}
		//将字符串赋给数组 
		day=str.toCharArray();
		if(day[0] == 'M'||day[0] == 'm' ) {
			System.out.println("判定为星期一");
		}else if(day[0] == 'T'||day[0] == 't' ) {
			System.out.println("请输入第二个字母");
			if(sc.hasNext()) {
				str=sc.next();
			}
			//将字符串赋给数组 
			day=str.toCharArray();
			if(day[0] == 'U'||day[0] == 'u') {
				System.out.println("判定为星期二");
			}else if(day[0] == 'H'||day[0] == 'h') {
				System.out.println("判定为星期四");
			}
		}else if(day[0] == 'W'||day[0] == 'w') {
			System.out.println("判定为星期三");
		}else if(day[0] == 'F'||day[0] == 'f') {
			System.out.println("判定为星期五");
		}else if(day[0] == 'S'||day[0] == 's') {
			
			//判断周六还是周日
			System.out.println("请输入第二个字母");
			if(sc.hasNext()) {
				str=sc.next();
			}
			//将字符串赋给数组 
			day=str.toCharArray();
			if(day[0] == 'A'||day[0] == 'a') {
				System.out.println("判定为星期六");
			}else if(day[0] == 'U'||day[0] == 'u') {
				System.out.println("判定为星期日");
			}
		}else {
			System.out.println("输入错误，退出");
		}
	}
	
	
	/**
	 *  判断回文数
	 * @param number 输入的数加L
	 * @return 返回true 或false
	 */
	private static boolean isPalindromic(long number) {
		//逆序数
		long reversed =reverseNum2(number);
		//判断是不是回文数
		if(reversed == number) {
			System.out.println(number+"是回文数");
			return true;
		}else {
			System.out.println(number+"不是回文数");
			return false;
		}
		
	}
	
	

	/*
	 * 给定一个整数，判断是几位数，求逆序数，判断是否为回文数
	 */
	private static long reverseNum2(long number) {
		// 存储逆序数
		long reversed = 0;
		// 整型转字符串
		String str0 = String.valueOf(number);
		// 字符串逆序排放
		String str1 = new StringBuffer(str0).reverse().toString();
		// 字符串转整型
		reversed = Integer.valueOf(str1);

		// 返回值
		System.out.println(number+"的逆序数为"+reversed);
		return reversed;
	}

	/**
	 * 求逆序数方法1
	 * 
	 * @param number
	 * @return
	 */
	private static long reverseNum(long number) {
		// 存储逆序数
		long reversed = 0;
		// 用数组实现逆序
		int[] arr = new int[18];
		// 存储每位的数据
		int bitNum = -1;
		// 确定有几位数
		int bits = 0;
		// 定义标志位
		boolean isBegin = false;
		// 初始化数组，让数组每个元素都为-1
		for (int i = 0; i < arr.length; i++) {
			arr[i] = -1;
		}
		// 找位数
		for (int i = 17; i >= 0; i--) {
			bitNum = (int) (number / (long) Math.pow(10, i) % 10);
			// 判断是不是找到第一位数
			if (bitNum != 0 && isBegin == false) {
				isBegin = true;
				bits = i;

			}
			if (isBegin == true) {
				arr[bits - i] = bitNum;
				System.out.println(bitNum);
			}
		}
		// 求逆序数
		for (int i = 0; i <= bits; i++) {
			reversed += arr[i] * Math.pow(10, i);
		}

		// 输出逆序数
		System.out.println(number + "的逆序数为" + reversed);

		// 返回逆序数
		return reversed;
	}

	/*
	 * 打印菱形
	 */
	/**
	 * 打印菱形
	 * 
	 * @param line
	 *            菱形的行数 奇数
	 */
	private static void printRhombus(int line) {
		// 打印上部的三角形
		for (int i = 0; i <= line / 2; i++) {
			// 打印空格
			for (int j = line / 2 - 1; j >= i; j--) {
				System.out.print(" ");
			}
			// 打印*
			for (int k = 0; k <= 2 * i; k++) {
				System.out.print("*");
			}
			// 每行打印完换行
			System.out.println();
		}
		// 打印下部的三角形
		for (int i = 0; i <= line / 2; i++) {
			// 打印空格
			for (int j = 0; j <= i; j++) {
				System.out.print(" ");
			}
			// 打印* 根据行数不同而不同
			if (line % 2 == 0) {
				for (int k = line - 2 * i - 1; k > 0; k--) {
					System.out.print("*");
				}
			} else {
				for (int k = line - 2 * i - 2; k > 0; k--) {
					System.out.print("*");
				}
			}
			// 每行打印完换行
			System.out.println();
		}

	}

	/*-
	 * indent
	 * 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。
	 * 问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。
	 * 问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。
	 * 请问第五个人多大？  
	 */

	/**
	 * 递归计算年龄
	 * 
	 * @param n
	 *            第几个人
	 * @return 年龄
	 */
	private static int seqAge(int n) {

		// 第n个人的岁数
		int ageN;
		// 数列递归
		if (n == 1) {
			ageN = 10;
		} else {
			ageN = seqAge(n - 1) + 2;
		}
		// 返回第n个人的岁数
		System.out.println("第" + n + "个人的岁数为" + ageN + "岁");
		return ageN;

	}

	/*
	 * 题目：求1+2!+3!+...+20!的和
	 */
	/**
	 * 出问题的点，应该用long的，不能用int 1+2!+3!+...+20!=2561327494111820313
	 * 
	 * @param n
	 *            最后的阶乘数
	 * @return 阶乘求和
	 */
	private static long sumFactor(int n) {
		// 阶乘的和
		long sumF = 0;
		// 求和
		for (int i = 1; i <= n; i++) {
			sumF += factorial(i);
		}

		// 输出并返回总和
		System.out.println("1+2!+3!+...+20!=" + sumF);
		return sumF;
	}

	/*
	 * 递归求阶乘 定义递归函数
	 */
	/**
	 * 出问题的点，应该用long的，不能用int
	 * 
	 * @param n
	 *            要求阶乘的数
	 * @return 返回阶乘结果
	 */
	private static long factorial(int n) {
		// 保存阶乘的结果变量
		long factor = 1;

		// 计算整数n的阶乘
		for (int i = n; i > 0; i--) {
			factor *= i;
		}

		// 返回阶乘的结果
		return factor;
	}

	/*-
	 * indent
	 * 20.题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
	 */

	private static double sumSeq() {
		// 数列的和
		double dSum = 0;
		// for循环计算数列求和
		for (int i = 1; i <= 20; i++) {
			// 第i个数为数列的i+1个数除以第i个数
			dSum += (double) seq(i + 1) / seq(i);
			// 为了确定数据正确的输出语句
			// System.out.println("当前数值为"+(double)seq(i+1)/seq(i));
		}
		// 输出和
		System.out.println("分数序列：2/1，3/2，5/3，8/5，13/8，21/13...的前20项之和" + dSum);
		// 返回所求值
		return dSum;

	}

	// 递归函数 计算数列的分子分母
	// 数列规律为1,2,3,5,8,13,21...
	private static int seq(int n) {
		// 根据n的值确定返回值
		if (n > 0) {
			if (n == 1) {
				return 1;
			} else if (n == 2) {
				return 2;
			} else {
				return seq(n - 1) + seq(n - 2);
			}
		} else {
			System.out.println("数列项是从1开始的，必须大于0");
			return 0;
		}
	}

	/*-
	 * indent
	 * 18.题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。
	 * 已抽签决定比赛名单。有人向队员打听比赛的名单。
	 * a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。   
	 */
	private static void list() {

		// 定义甲队的数组，用来存储甲队比赛名单
		char[] arr0 = new char[3];
		// 定义乙队的数组
		char[] arr1 = { 'x', 'y', 'z' };

		// 根据乙队的数组判断对应的名单

		// c 不和x,z比
		for (int j = 0; j < arr1.length; j++) {
			if (arr1[j] != 'x' && arr1[j] != 'z') {
				arr0[j] = 'c';
			}
		}
		// a不和x比
		for (int j = 0; j < arr1.length; j++) {
			if (arr1[j] != 'x' && arr0[j] != 'c') {
				arr0[j] = 'a';
			}
		}
		// 剩余一个位置为b的
		for (int j = 0; j < arr1.length; j++) {
			if (arr0[j] != 'a' && arr0[j] != 'c') {
				arr0[j] = 'b';
			}
		}

		// 循环输出比赛名单
		for (int i = 0; i < arr0.length; i++) {
			System.out.println("比赛中甲队" + arr0[i] + "与乙队" + arr1[i] + "对战");
		}
	}

	/*
	 * 题目：输入某年某月某日，判断这一天是这一年的第几天？
	 */
	/**
	 * @param iYear
	 *            输入年份
	 * 
	 * @param iMonth
	 *            输入月份
	 * @param iDay
	 *            输入天
	 */
	private static void day(int iYear, int iMonth, int iDay) {
		// 天数
		int day = iDay;
		// 将month赋给中间变量
		int month = iMonth;

		// 循环递减，统计当月之前的整月的天数
		// 当month递减到1时，就只计算iDay
		while (month > 0) {
			// switch
			switch (month) {
			// 当月的天数
			case 1:
				System.out.println(iYear + "年" + iMonth + "月" + iDay + "日是当年的第" + day + "天");
				// 2月完整的天数
			case 3:
				if (iYear % 400 == 0 || iYear % 4 == 0 && iYear % 100 != 0) {
					day += 29;
					break;
				} else {
					day += 28;
					break;
				}
				// 1 3 5 7 8 10 月完整天数为31天
			case 2:
			case 4:
			case 6:
			case 9:
			case 11:
				day += 31;
				break;
			// 4 6 9 11月完整的天数为30天
			case 5:
			case 7:
			case 8:
			case 10:
			case 12:
				day += 30;
				break;

			}
			// 循环因子
			month--;
		}
	}

	/*
	 * 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
	 */

	/**
	 * i=-99 i=21 i=261
	 */
	private static void num100168() {

		// 初始化循环因子
		int i = -100;
		// 平方根
		int iSqrt;

		// while循环
		while (i + 100 >= 0 && i < 1000) {
			// 求i+100的平方根
			iSqrt = (int) Math.sqrt(i + 100);
			// 如果平方根想乘为i
			if (iSqrt * iSqrt == i + 100) {
				// 进而判断+168的条件是不是成立
				iSqrt = (int) Math.sqrt(i + 100 + 168);
				if (iSqrt * iSqrt == i + 100 + 168) {
					System.out.println("i=" + i);
				}
			}

			i++;
		}
	}

	/*
	 * 定义一个足够大的数组，用来存放数值计算问题的结果
	 * 
	 */
	private static int[] bigArray() {
		// 数组变量
		int[] numArr = new int[1000];

		return numArr;
	}

	/*
	 * 打印数组
	 */
	private static void printArr(int[] arr) {
		// for遍历数组
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == 0) {
				System.out.println("输出结束");
				break;
			}
			System.out.print(arr[i] + " ");
		}
		// 换行
		System.out.println();
	}

	/*
	 * 1,2,3,4组成多少个互不相同且无重复数字的三位数？都是多少？
	 */
	private static void makeNum1(int[] arr) {
		// 统计个数
		int count = 0;
		// 定义数组变量
		int i = 0;
		// 遍历三位数
		for (int a = 100; a <= 432; a++) {
			// 如果a的个位十位百位均不相等，且都在1到4范围内
			if (a / 100 >= 1 && a / 100 <= 4 && a / 10 % 10 >= 1 && a / 10 % 10 <= 4 && a % 10 >= 1 && a % 10 <= 4
					&& a / 100 != a % 10 && a / 100 != a / 10 % 10 && a / 10 % 10 != a % 10) {
				arr[i++] = a;
				count++;
			}
		}

		// 输出
		System.out.println("1,2,3,4一共能组成" + count + "个互不相同且无重复数字的三位数。");
	}

	/*
	 * 1,2,3,4组成多少个互不相同且无重复数字的三位数？都是多少？
	 */
	private static void makeNum(int[] arr) {
		// 统计个数
		int count = 0;
		// 定义遍历变量
		int i = 0, j = 0, k = 0, a = 0;
		// 遍历数组，给元素赋值
		// for (a = 0; a < arr.length; a++) {
		// 遍历循环1-4组成不同的数
		for (i = 1; i <= 4; i++) {
			for (j = 1; j <= 4; j++) {
				for (k = 1; k <= 4; k++) {
					// 只要互不相等就统计个数
					if (i != j && j != k && k != i) {
						count++;
						// 输出数据
						arr[a++] = i * 100 + j * 10 + k;
					}

				}
			}
		}
		// if (i == 4 && j == 3 && k == 2) {
		// break;
		// }
		// }

		// 输出
		System.out.println("1,2,3,4一共能组成" + count + "个互不相同且无重复数字的三位数。");
	}

	/*-indent
	 * 题目：有1、2、3、4四个数字，
	 * 能组成多少个互不相同且无重复数字的三位数？都是多少？
	 */
	private static void makeNum() {
		// 统计个数
		int count = 0;
		// 遍历循环1-4组成不同的数
		for (int i = 1; i <= 4; i++) {
			for (int j = 1; j <= 4; j++) {
				for (int k = 1; k <= 4; k++) {
					// 只要互不相等就统计个数
					if (i != j && j != k && k != i) {
						count++;
						// 输出数据
						System.out.println(i * 100 + j * 10 + k);
					}
				}
			}
		}

		// 输出
		System.out.println("1,2,3,4一共能组成" + count + "个互不相同且无重复数字的三位数。");
	}

	/*-indent
	 * 题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；
	 * 再落下，求它在     第10次落地时，共经过多少米？第10次反弹多高？
	 * 思路：定义两个参数接收100和10
	 * 		共经过多少米 ---累加和变量sum
	 * 		第10次反弹多高---单次高度height
	 * 		
	 */
	/**
	 * @param high
	 *            自由落体原始高度
	 * @param times
	 *            落地次数/反弹次数
	 */
	private static void falling(double high, int times) {
		// 定义累加和
		double dSum = high;
		// 定义单次反弹高度
		double height = high / 2;

		// while
		int i = 2;
		while (i <= times) {
			// 第i次落地时经过的距离
			dSum += height * 2;
			// 第i次反弹的高度
			height /= 2;
			// 自增
			i++;
		}

		// 输出
		System.out.println("第" + times + "次落地时，共经过" + dSum + "米.第" + times + "次反弹" + height + "米.");

	}

	/*-indent
	 * 一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。 
	 * 例如6=1＋2＋3.编程 找出1000以内的所有完数。
	 */

	/**
	 * 取n1为-10，n为10 因为正负相抵，结果只能找到0 这不符合完数概念，负数计算完数么？ 负数可以转化为整数考虑，然后统计因子个数 偶数
	 * 肯定不行，奇数可以 为什么6,28,496除去自身因子都是9个。。。 我傻了，因子肯定是成对出现的，除了自身和1配套以外，其他肯定是偶数个
	 * 
	 * @param n1
	 *            起始位置
	 * @param n
	 *            终止为止
	 */
	private static void perfactNum(int n1, int n) {

		// 定义累加和
		int sum = 0;
		// 统计完数个数
		int count = 0;
		// 输出找n以内的完数
		System.out.println(n + "以内的完数有：");

		// for循环找出因子，并计算累加和
		for (int i = n1; i <= n; i++) {
			// 对每个数初始化累加和为0
			// 经常忘了这个
			sum = 0;
			// 遍历从1到i-1找因子进行累加和
			for (int j = 1; j < i; j++) {
				if (i % j == 0) {
					sum += j;
					count++;
				}
			}
			// 如果因子累加和等于原数则为完数输出
			if (sum == i) {
				System.out.println(i);
			}
		}
		// 当范围够小或者两个数之间的范围时有可能存在找不到完数
		if (count == 0) {
			System.out.println(n + "以内的没有完数");
		}
	}

	/**
	 * 求n以内的完数
	 * 
	 * @param n
	 *            可以定义两个参数求一定范围内的完数
	 */
	private static void perfactNum(int n) {

		// 定义累加和
		int sum = 0;
		// 统计完数个数
		int count = 0;
		// 输出找n以内的完数
		System.out.println(n + "以内的完数有：");

		// for循环找出因子，并计算累加和
		for (int i = 2; i <= n; i++) {
			// 对每个数初始化累加和为0
			// 经常忘了这个
			sum = 0;
			// 遍历从1到i-1找因子进行累加和
			for (int j = 1; j < i; j++) {
				if (i % j == 0) {
					sum += j;
					count++;
				}
			}
			// 如果因子累加和等于原数则为完数输出
			if (sum == i) {
				System.out.println(i);
			}
		}
		// 当范围够小或者两个数之间的范围时有可能存在找不到完数
		if (count == 0) {
			System.out.println(n + "以内的没有完数");
		}
	}

	/*-
	 * indent
	 * 求s=a+aa+aaa+aaaa+aa...a的值，* 其中a是一个数字。
	 * 例如2+22+222+2222+22222(此时共有5个数相加)，
	 * 几个数相加有键盘控制。
	 */
	private static int iSum(int a, int num) {

		// 求和变量
		int sum = 0;
		// 定义第i个数的值
		int iVal = 0;

		// 遍历a个数
		for (int i = 1; i <= num; i++) {
			iVal = 0;
			// 计算第a个数的值
			for (int j = 0; j < i; j++) {
				// 计算第i个数
				// 可以直接用sum求
				// sum+=a*Math.pow(10, j);
				iVal += a * Math.pow(10, j);
			}
			// 输出第i个数
			System.out.println("iVal(" + i + ")=" + iVal);
			sum += iVal;
		}

		// 输出
		System.out.println("当a=" + a + "时，s=a+aa+aaa+aaaa+aa...a的值为" + sum);
		return sum;
	}

	/*-
	 * 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 
	 */
	/*
	 * 思路：输入一个字符串 统计字符串中字符的个数，创建一个个数+1的字符数组 for循环遍历数组，字符在某一范围内，给该范围的计数变量自增 0-9
	 * a-z||A-Z ' ' 中文的范围 unicode最小和最大 else 为其他
	 * 
	 * 如果需要返回值可以用数组存放个数
	 */
	private static void countNum() {

		// 统计数字的个数
		int countNums = 0;
		// 统计英文字母个数
		int countCharas = 0;
		// 统计空格个数
		int countSpacings = 0;
		// 统计中文字符个数
		int countChineses = 0;
		// 统计其他字符的个数
		int countOthers = 0;

		// 新建一个scanner类
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一段字符串");
		// 循环直至接收完成
		while (!sc.hasNext()) {
			// 输入字符串
			System.out.println("没有输入，请输入一段字符串");
		}
		// 接受字符串
		String recvString = sc.nextLine();

		// 求接收的字符串的字符个数
		int count = recvString.length();
		System.out.println(count);

		// 定义字符数组接收
		char[] chStr = new char[count];
		// 将字符串转换为字符数组
		chStr = recvString.toCharArray();

		// 遍历数组 计算数组中各种字符的个数
		for (int i = 0; i < chStr.length; i++) {
			if (chStr[i] >= '0' && chStr[i] <= '9') {
				countNums++;
			} else if (chStr[i] >= 'a' && chStr[i] <= 'z' || chStr[i] >= 'A' && chStr[i] <= 'Z') {
				countCharas++;
			} else if (chStr[i] == ' ') {
				countSpacings++;
			} else if (chStr[i] > '\u4E00' && chStr[i] <= '\u9FA5') {
				countChineses++;
			} else {
				countOthers++;
			}
		}

		// 输出每种字符有多少个
		{
			System.out.println("中文字符有" + countChineses + "个");
			System.out.println("英文字母有" + countCharas + "个");
			System.out.println("数字有" + countNums + "个");
			System.out.println("空格有" + countSpacings + "个");
			System.out.println("其他字符有" + countOthers + "个");
		}
	}

	/*
	 * 输入两个正整数m和n，求其最大公约数和最小公倍数。
	 */

	/**
	 * @param a
	 *            数1
	 * @param b
	 *            数2
	 * @return maxDiv 返回-1 没有最大公约数 ，其他正数为有最大公约数
	 */
	private static int maxDivisor(int a, int b) {
		// 定义最大公约数
		int maxDiv = -1;
		// 标志有没有最大公约数
		boolean flag = false;
		// 遍历2到两个数中比较小的那个
		// 如果都能整除，就是公约数
		// 遍历完就能得到最大公约数
		// 可以优化，倒着来，先得到的就是最大公约数
		for (int i = 2; i <= (a < b ? a : b); i++) {
			if (a % i == 0 && b % i == 0) {
				maxDiv = i;
				flag = true;
			}
		}
		if (flag) {
			System.out.println(a + "和" + b + "的最大公约数是" + maxDiv);
		} else {
			System.out.println(a + "和" + b + "没有最大公约数");
		}
		return maxDiv;
	}

	/**
	 * @param a
	 *            数1
	 * @param b
	 *            数2
	 * @return 最小公倍数
	 */
	private static int minMultiple(int a, int b) {
		// 定义最小公倍数
		int minMul = -1;
		// 遍历大的数值到两个数乘积
		for (int i = (a > b ? a : b); i <= a * b; i++) {
			if (i % a == 0 && i % b == 0) {
				minMul = i;
				break;
			}
		}
		// 输出
		System.out.println(a + "和" + b + "的最小公倍数是" + minMul);
		return minMul;
	}

	/**
	 * 
	 * @param score
	 */
	/*
	 * 题目：利用条件运算符的嵌套来完成此题： 学习成绩> =90分的同学用A表示， 60-89分之间的用B表示，60分以下的用C表示。
	 * 
	 */
	private static void output(int score) {
		// 等级
		char chGrade;
		// 成绩判断等级
		chGrade = (score >= 90) ? 'A' : (score >= 60 && score <= 89) ? 'B' : 'C';

		// 输出
		System.out.println(score + "分判定等级为" + chGrade);

	}

	/*-
	 * 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。   
	 * 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：   
	 * (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。   
	 * (2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。   
	 * (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
	 * 
	 */
	private static void decompose(int num) {
		// 定义最小质因数
		int minPrime = 1;
		// 定义中间变量
		int n = num;
		// 找到最小质因数
		for (int i = 2; i <= num; i++) {
			if (num % i == 0) {
				minPrime = i;
				break;
			}
		}
		// 打印输出
		System.out.print(num + "=");
		while (true) {
			//
			if (minPrime == n) {
				System.out.print(n);
				break;
			} else if (n % minPrime == 0) {
				System.out.print(minPrime + "*");
				n = n / minPrime;
				continue;
			} else if (n % minPrime != 0) {
				minPrime = minPrime + 1;
			}

		}
	}

	/*-
	 * indent
	 * 题目：打印出所有的 "水仙花数 "，
	 * 所谓 "水仙花数 "是指一个三位数，
	 * 其各位数字立方和等于该数本身。
	 * 例如：153是一个 "水仙花数 "，
	 * 因为153=1的三次方＋5的三次方＋3的三次方。 
	 */
	private static void narcissistic() {
		// 统计数量
		int count = 0;

		// for循环所有三位数
		for (int i = 100; i < 1000; i++) {
			// 各位数字立方和等于该数本身
			if (Math.pow(i / 100, 3) + Math.pow(i / 10 % 10, 3) + Math.pow(i % 10, 3) == i) {
				System.out.print(i + " ");
				// 不够十个，153,370,371，407
				// if(count%10==0) {
				// System.out.println();
				// }
			}
		}
	}

	/*
	 * 找素数
	 */
	private static void findPrime() {
		// scan
		Scanner sc = new Scanner(System.in);
		// 设定初始值和终止值
		int start, end;
		// 赋值
		System.out.println("寻找两个数之间的素数：");
		System.out.println("请输入起始值：");
		start = sc.nextInt();
		System.out.println("请输入终止值：");
		end = sc.nextInt();
		printPrime(start, end);
	}

	/*-
	 * indent
	 * 判断101-200之间有多少个素数，并输出所有素数。
	 */
	private static void printPrime(int start, int end) {
		// 统计素数的个数
		int count = 0;
		// 定义素数的标志位
		boolean isPrime = true;
		// 输出
		System.out.println(start + "-" + end + "之间的素数有：");

		// 循环遍历数据
		for (int i = start; i <= end; i++) {
			// 求素数
			isPrime = true;
			for (int j = 2; j < Math.sqrt(i); j++) {
				if (i % j == 0) {
					isPrime = false;
				}
			}
			if (isPrime) {
				count++;
				System.out.print(i + " ");
			}
			if (count % 10 == 0 && isPrime == true) {
				System.out.println();
			}
		}
		System.out.println();
		// 输出信息
		if (count == 0) {
			System.out.println(start + "-" + end + "之间没有素数");
		} else {
			System.out.println(start + "-" + end + "之间的素数有" + count + "个");
		}
	}

	// 兔子数列
	private static void countRabbit() {
		// scanner实例
		Scanner sc = new Scanner(System.in);
		// 输入月份
		System.out.println("请输入计算兔子数量的月份：");
		int month = sc.nextInt();
		// 调用方法 计算结果
		int result = Fibonacci(month) * 2;
		System.out.println("第" + month + "月有" + result + "只兔子");
	}

	/*-
	 * indent
	 * 古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，
	 * 小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，
	 * 问每个月的兔子总数为多少？   
	 */
	private static int Fibonacci(int month) {
		// 定义斐波那契数列
		int result;
		// 第一个月 0只
		// 第二个月 1只
		// 第三个月开始f(n-1)+f(n-2)
		if (month == 0) {
			result = 0;
		} else if (month == 1) {
			result = 1;
		} else {
			result = Fibonacci(month - 1) + Fibonacci(month - 2);
		}
		// 返回
		return result;
	}

	/*
	 * 题目：输入一个年份，判定该年是闰年还是平年。
	 */
	/**
	 * @param year
	 *            年份
	 */
	private static void isLeapYear(int year) {
		// 判断是否是闰年然后输出
		if (year % 400 == 0 || year % 100 != 0 && year % 4 == 0) {
			System.out.println(year + "年是闰年");
		} else {
			System.out.println(year + "年不是闰年");
		}
	}

}
